"""
模板数据 CRUD 操作
用于模板数据的数据库操作
"""
from typing import Optional
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from crud.base import CRUDBase
from models.template_data import TemplateData
from schemas.template_data import TemplateDataCreate, TemplateDataUpdate


class CRUDTemplateData(CRUDBase[TemplateData, TemplateDataCreate, TemplateDataUpdate]):
    """模板数据 CRUD 操作"""
    
    async def create_with_relations(
        self,
        db: AsyncSession,
        *,
        obj_in: TemplateDataCreate,
        template_name: Optional[str] = None,
        patient_name: Optional[str] = None
    ) -> TemplateData:
        """
        创建模板数据（带冗余字段）
        
        Args:
            db: 数据库会话
            obj_in: 模板数据创建 Schema
            template_name: 模板名称（冗余字段）
            patient_name: 患者姓名（冗余字段）
            
        Returns:
            创建的模板数据对象
        """
        db_obj = TemplateData(
            template_id=obj_in.template_id,
            template_name=template_name,
            template_version=obj_in.template_version,
            patient_id=obj_in.patient_id,
            patient_name=patient_name,
            doctor_id=obj_in.doctor_id,
            medical_record_id=obj_in.medical_record_id,
            form_data=obj_in.form_data,
            status=obj_in.status if obj_in.status is not None else 1  # 使用传入的 status，默认为 1
        )
        db.add(db_obj)
        await db.flush()
        await db.refresh(db_obj)
        return db_obj
    
    async def get_by_patient(
        self,
        db: AsyncSession,
        *,
        patient_id: int,
        status: int = None,
        skip: int = 0,
        limit: int = 100
    ) -> list[TemplateData]:
        """
        根据患者ID查询模板数据
        
        Args:
            db: 数据库会话
            patient_id: 患者ID
            status: 状态过滤（可选），None表示返回所有状态
            skip: 跳过记录数
            limit: 返回记录数
            
        Returns:
            模板数据列表
        """
        query = select(self.model).where(self.model.patient_id == patient_id)
        
        # 如果指定了状态，则添加状态过滤
        if status is not None:
            query = query.where(self.model.status == status)
        
        query = query.offset(skip).limit(limit).order_by(self.model.created_at.desc())
        
        result = await db.execute(query)
        return list(result.scalars().all())
    
    async def get_by_medical_record(
        self,
        db: AsyncSession,
        *,
        medical_record_id: int,
        skip: int = 0,
        limit: int = 100
    ) -> list[TemplateData]:
        """
        根据病历ID查询模板数据
        
        Args:
            db: 数据库会话
            medical_record_id: 病历ID
            skip: 跳过记录数
            limit: 返回记录数
            
        Returns:
            模板数据列表
        """
        result = await db.execute(
            select(self.model)
            .where(self.model.medical_record_id == medical_record_id)
            # 移除 status 过滤，显示所有状态的记录（包括待完成的）
            .offset(skip)
            .limit(limit)
            .order_by(self.model.created_at.desc())
        )
        return list(result.scalars().all())
    
    async def check_duplicate(
        self,
        db: AsyncSession,
        *,
        template_id: int,
        medical_record_id: int
    ) -> Optional[TemplateData]:
        """
        检查同一病例下是否已存在相同模板
        
        Args:
            db: 数据库会话
            template_id: 模板ID
            medical_record_id: 病历ID
            
        Returns:
            如果存在则返回已存在的记录，否则返回 None
        """
        result = await db.execute(
            select(self.model)
            .where(
                self.model.template_id == template_id,
                self.model.medical_record_id == medical_record_id
            )
            .limit(1)
        )
        return result.scalars().first()


# 创建全局实例
crud_template_data = CRUDTemplateData(TemplateData)




